/*
package com.huey.utils.fx;

import com.deepexi.util.extension.ApplicationException;
import com.galaxy.redis.service.RedisService;
import com.galaxy.redis.util.JacksonUtil;
import com.glxytech.cloud.cost.enums.payments.SequenceTypeEnum;
import com.google.common.collect.Lists;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;

*/
/**
 * 生成序号通用服务
 *
 * @author qmmao
 *//*

@Component
public class SequenceManager {
    */
/**
     * incr的补0的位数 4位
     *//*

    private static final int INCR_FORMAT_NUM_FOUR = 4;

    */
/**
     * incr的补0的位数 5位
     *//*

    private static final int INCR_FORMAT_NUM_FIVE = 5;

    */
/**
     * incr的补0的位数 2位
     *//*

    public static final int INCR_FORMAT_NUM_TWO = 2;

    */
/**
     * Time format : yyyyMMddHHmm
     *//*

    public static final String DATE_TIME_MINUTE_FORMAT = "yyyyMMddHHmm";

    @Autowired
    private RedisService redisService;

    */
/**
     * 根据序号类型获取下一个流水号
     *
     * @param sequenceTypeEnum
     * @return
     *//*

    public String getNineTeenDigitNo(SequenceTypeEnum sequenceTypeEnum) {
        String nowDate = LocalDate.now().toString();
        Long incrNum = redisService.incr(nowDate);
        String dateTime = DateTimeFormatter.ofPattern(DATE_TIME_MINUTE_FORMAT).format(LocalDateTime.now());
        return sequenceTypeEnum.getCode() + dateTime + autoGenericCode(String.valueOf(incrNum), INCR_FORMAT_NUM_FOUR);
    }

    */
/**
     * 不够位数的在前面补0，保留num的长度位数字
     *
     * @param code 数据
     * @param num  长度
     * @return 补0后的数据
     *//*

    public static String autoGenericCode(String code, int num) {
        String str = "%0" + num + "d";
        return String.format(str, Integer.parseInt(code));
    }

    */
/**
     * 线程安全自增编码生成器
     *
     * @param lockKey    分布式锁
     * @param prefix     编码前缀
     * @param start      默认编码起始值
     * @param size       编码个数
     * @param incrFormat 编码后几位自增并填充0
     * @return
     *//*

    public List<String> threadSafeFiveSerialCodeGenerate(String lockKey, String prefix, Integer start, Integer size, Integer incrFormat) {
        // redis分布式锁
        String redisLockKey = "redis-lock:" + lockKey;
        // redis分布式锁默认值
        String defaultValue = "default-value";
        List<String> result = Lists.newArrayList();
        // 加锁失败（加锁语句不能放入try语句块，因为这样会导致没有获取到锁的代码也能释放锁，产生bug）
        if (!redisService.tryLock(redisLockKey, defaultValue)) {
            return result;
        }
        try {
            // 判断redis是否存储序列值
            boolean exists = redisService.exists(lockKey);
            // redis存储了序列值
            if (exists) {
                // 读取redis存储的序列值
                Integer value = JacksonUtil.readValue(redisService.get(lockKey), Integer.class);
                // 根据批量数计算返回结果
                for (int i = 1; i <= size; i++) {
                    result.add(prefix + autoGenericCode(String.valueOf(value + i), incrFormat));
                }
                // 修改redis序列值
                redisService.incrBy(lockKey, size);
                return result;
            }
            // redis未存储序列值（可能redis宕机导致数据被清楚了）
            for (int i = 1; i <= size; i++) {
                result.add(prefix + autoGenericCode(String.valueOf(start + i), incrFormat));
            }
            redisService.incrBy(lockKey, start + size);
        } catch (Exception e) {
            throw new ApplicationException("编码生成失败");
        } finally {
            // 释放锁
            redisService.releaseLock(redisLockKey, defaultValue);
        }
        return result;
    }

    */
/**
     * 线程安全自增编码生成器
     *
     * @param lockKey    分布式锁
     * @param prefix     编码前缀
     * @param start      默认编码起始值
     * @param size       编码个数
     * @param incrFormat 编码后几位自增并填充0
     * @param life       key保存时间
     * @return
     *//*

    public List<String> threadSafeFiveSerialCodeGenerate(String lockKey, String prefix, Integer start, Integer size, Integer incrFormat, Integer life) {
        // redis分布式锁
        String redisLockKey = "redis-lock:" + lockKey;
        // redis分布式锁默认值
        String defaultValue = "default-value";
        List<String> result = Lists.newArrayList();
        // 加锁失败（加锁语句不能放入try语句块，因为这样会导致没有获取到锁的代码也能释放锁，产生bug）
        if (!redisService.tryLock(redisLockKey, defaultValue)) {
            return result;
        }
        try {
            // 判断redis是否存储序列值
            boolean exists = redisService.exists(lockKey);
            // redis存储了序列值
            if (exists) {
                // 读取redis存储的序列值
                Integer value = JacksonUtil.readValue(redisService.get(lockKey), Integer.class);
                // 根据批量数计算返回结果
                for (int i = 1; i <= size; i++) {
                    result.add(prefix + autoGenericCode(String.valueOf(value + i), incrFormat));
                }
                // 修改redis序列值
                redisService.incrBy(lockKey, size);
                return result;
            }
            // redis未存储序列值（可能redis宕机导致数据被清楚了）
            for (int i = 1; i <= size; i++) {
                result.add(prefix + autoGenericCode(String.valueOf(start + i), incrFormat));
            }
            redisService.incrBy(lockKey, start + size);
            redisService.expire(lockKey, life);
        } catch (Exception e) {
            throw new ApplicationException("编码生成失败");
        } finally {
            // 释放锁
            redisService.releaseLock(redisLockKey, defaultValue);
        }
        return result;
    }
}
*/
